home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / dis.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  6KB  |  255 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. '''Disassembler of Python byte code into mnemonics.'''
  5. import sys
  6. import types
  7. from opcode import *
  8. from opcode import __all__ as _opcodes_all
  9. __all__ = [
  10.     'dis',
  11.     'disassemble',
  12.     'distb',
  13.     'disco'] + _opcodes_all
  14. del _opcodes_all
  15.  
  16. def dis(x = None):
  17.     '''Disassemble classes, methods, functions, or code.
  18.  
  19.     With no argument, disassemble the last traceback.
  20.  
  21.     '''
  22.     if x is None:
  23.         distb()
  24.         return None
  25.     
  26.     if type(x) is types.InstanceType:
  27.         x = x.__class__
  28.     
  29.     if hasattr(x, 'im_func'):
  30.         x = x.im_func
  31.     
  32.     if hasattr(x, 'func_code'):
  33.         x = x.func_code
  34.     
  35.     if hasattr(x, '__dict__'):
  36.         items = x.__dict__.items()
  37.         items.sort()
  38.         for name, x1 in items:
  39.             if type(x1) in (types.MethodType, types.FunctionType, types.CodeType, types.ClassType):
  40.                 print 'Disassembly of %s:' % name
  41.                 
  42.                 try:
  43.                     dis(x1)
  44.                 except TypeError:
  45.                     msg = None
  46.                     print 'Sorry:', msg
  47.  
  48.                 print 
  49.                 continue
  50.         
  51.     elif hasattr(x, 'co_code'):
  52.         disassemble(x)
  53.     elif isinstance(x, str):
  54.         disassemble_string(x)
  55.     else:
  56.         raise TypeError, "don't know how to disassemble %s objects" % type(x).__name__
  57.  
  58.  
  59. def distb(tb = None):
  60.     '''Disassemble a traceback (default: last traceback).'''
  61.     if tb is None:
  62.         
  63.         try:
  64.             tb = sys.last_traceback
  65.         except AttributeError:
  66.             raise RuntimeError, 'no last traceback to disassemble'
  67.  
  68.         while tb.tb_next:
  69.             tb = tb.tb_next
  70.     
  71.     disassemble(tb.tb_frame.f_code, tb.tb_lasti)
  72.  
  73.  
  74. def disassemble(co, lasti = -1):
  75.     '''Disassemble a code object.'''
  76.     code = co.co_code
  77.     labels = findlabels(code)
  78.     linestarts = dict(findlinestarts(co))
  79.     n = len(code)
  80.     i = 0
  81.     extended_arg = 0
  82.     free = None
  83.     while i < n:
  84.         c = code[i]
  85.         op = ord(c)
  86.         if i in linestarts:
  87.             if i > 0:
  88.                 print 
  89.             
  90.             print '%3d' % linestarts[i],
  91.         else:
  92.             print '   ',
  93.         if i == lasti:
  94.             print '-->',
  95.         else:
  96.             print '   ',
  97.         if i in labels:
  98.             print '>>',
  99.         else:
  100.             print '  ',
  101.         print repr(i).rjust(4), opname[op].ljust(20),
  102.         i = i + 1
  103.         if op >= HAVE_ARGUMENT:
  104.             oparg = ord(code[i]) + ord(code[i + 1]) * 256 + extended_arg
  105.             extended_arg = 0
  106.             i = i + 2
  107.             if op == EXTENDED_ARG:
  108.                 extended_arg = oparg * 0x10000L
  109.             
  110.             print repr(oparg).rjust(5),
  111.             if op in hasconst:
  112.                 print '(' + repr(co.co_consts[oparg]) + ')',
  113.             elif op in hasname:
  114.                 print '(' + co.co_names[oparg] + ')',
  115.             elif op in hasjrel:
  116.                 print '(to ' + repr(i + oparg) + ')',
  117.             elif op in haslocal:
  118.                 print '(' + co.co_varnames[oparg] + ')',
  119.             elif op in hascompare:
  120.                 print '(' + cmp_op[oparg] + ')',
  121.             elif op in hasfree:
  122.                 if free is None:
  123.                     free = co.co_cellvars + co.co_freevars
  124.                 
  125.                 print '(' + free[oparg] + ')',
  126.             
  127.         
  128.         print 
  129.  
  130.  
  131. def disassemble_string(code, lasti = -1, varnames = None, names = None, constants = None):
  132.     labels = findlabels(code)
  133.     n = len(code)
  134.     i = 0
  135.     while i < n:
  136.         c = code[i]
  137.         op = ord(c)
  138.         if i == lasti:
  139.             print '-->',
  140.         else:
  141.             print '   ',
  142.         if i in labels:
  143.             print '>>',
  144.         else:
  145.             print '  ',
  146.         print repr(i).rjust(4), opname[op].ljust(15),
  147.         i = i + 1
  148.         if op >= HAVE_ARGUMENT:
  149.             oparg = ord(code[i]) + ord(code[i + 1]) * 256
  150.             i = i + 2
  151.             print repr(oparg).rjust(5),
  152.             if op in hasconst:
  153.                 if constants:
  154.                     print '(' + repr(constants[oparg]) + ')',
  155.                 else:
  156.                     print '(%d)' % oparg,
  157.             elif op in hasname:
  158.                 if names is not None:
  159.                     print '(' + names[oparg] + ')',
  160.                 else:
  161.                     print '(%d)' % oparg,
  162.             elif op in hasjrel:
  163.                 print '(to ' + repr(i + oparg) + ')',
  164.             elif op in haslocal:
  165.                 if varnames:
  166.                     print '(' + varnames[oparg] + ')',
  167.                 else:
  168.                     print '(%d)' % oparg,
  169.             elif op in hascompare:
  170.                 print '(' + cmp_op[oparg] + ')',
  171.             
  172.         
  173.         print 
  174.  
  175. disco = disassemble
  176.  
  177. def findlabels(code):
  178.     '''Detect all offsets in a byte code which are jump targets.
  179.  
  180.     Return the list of offsets.
  181.  
  182.     '''
  183.     labels = []
  184.     n = len(code)
  185.     i = 0
  186.     while i < n:
  187.         c = code[i]
  188.         op = ord(c)
  189.         i = i + 1
  190.         if op >= HAVE_ARGUMENT:
  191.             oparg = ord(code[i]) + ord(code[i + 1]) * 256
  192.             i = i + 2
  193.             label = -1
  194.             if op in hasjrel:
  195.                 label = i + oparg
  196.             elif op in hasjabs:
  197.                 label = oparg
  198.             
  199.             if label >= 0:
  200.                 if label not in labels:
  201.                     labels.append(label)
  202.                 
  203.             
  204.         label >= 0
  205.     return labels
  206.  
  207.  
  208. def findlinestarts(code):
  209.     '''Find the offsets in a byte code which are start of lines in the source.
  210.  
  211.     Generate pairs (offset, lineno) as described in Python/compile.c.
  212.  
  213.     '''
  214.     byte_increments = [ ord(c) for c in code.co_lnotab[0::2] ]
  215.     line_increments = [ ord(c) for c in code.co_lnotab[1::2] ]
  216.     lastlineno = None
  217.     lineno = code.co_firstlineno
  218.     addr = 0
  219.     for byte_incr, line_incr in zip(byte_increments, line_increments):
  220.         lineno += line_incr
  221.     
  222.     if lineno != lastlineno:
  223.         yield (addr, lineno)
  224.     
  225.  
  226.  
  227. def _test():
  228.     '''Simple test program to disassemble a file.'''
  229.     if sys.argv[1:]:
  230.         if sys.argv[2:]:
  231.             sys.stderr.write('usage: python dis.py [-|file]\n')
  232.             sys.exit(2)
  233.         
  234.         fn = sys.argv[1]
  235.         if not fn or fn == '-':
  236.             fn = None
  237.         
  238.     else:
  239.         fn = None
  240.     if fn is None:
  241.         f = sys.stdin
  242.     else:
  243.         f = open(fn)
  244.     source = f.read()
  245.     if fn is not None:
  246.         f.close()
  247.     else:
  248.         fn = '<stdin>'
  249.     code = compile(source, fn, 'exec')
  250.     dis(code)
  251.  
  252. if __name__ == '__main__':
  253.     _test()
  254.  
  255.